de: Integer; front: Boolean);

 12;

 8;

gInt;

 69;

 6;

: Fixed);

ded): Extended;

Integer): Extended;

 dstRgn: RgnHandle);

$80;

ded): Fract;

ded): Fixed;

-74;

-61;

ce: Handle);

Err;

XT; OPT EXPR_LIST);

; OPT EXPR_LIST);

-123;

-44;

 0;

 3;

 6;

 5;

 3;

 4;

 2;

 1;

 30;

 1;

 5;

 6;

 0;

 4;

 2;

 4;

lean;

ElemPtr): OSErr;

-55;

-53;

-46;

ElemPtr): OSErr;

Rect);

: Fixed);

 5;

 2;

 RgnHandle);

ct: Rect);

 8;

 8;

 0;

 Integer);

 0;

 1;

 2;

55; diacSens: Boolean);

updateRgn: rgnHandle);

 Integer);

 64;

 6;

r; update: RgnHandle);

Ptr; dstBytes: Integer);

RefNum: Integer): OSErr;

Addr: Ptr);

gInt;

Type): Integer;

Type): Integer;

 dstRgn: RgnHandle);

 VAR dstRect: Rect);

 2;

-78;

 5;

et: Integer; srcMask: LongInt): OSErr;

dz: Fixed);

VAR dst: Point3D);

 thePt: Point): Boolean;

Point; actionProc: ProcPtr): Integer;

nt; partCode: Integer): Boolean;

 9;

tr;

1098;

1097;

-121;

-42;

-76;

gInt;

 6;

byteCount: Integer): Integer;

Integer);

Integer);

 0;

Integer);

 Style);

gInt; r: Rect; style: Integer);

t; h: TEHandle);

Err;

EHandle);

ct: Rect): TEHandle;

ST: StScrpHandle; hTE: TEHandle);

on): Boolean;

on): Boolean;

bute: Integer): Boolean;

le; thePt: Point): Integer;

 1;

h: LongInt; h: TEHandle);

 TextStyle; redraw: Boolean;

LongInt; h: TEHandle);

 LongInt);

r; h: TEHandle);

EHandle);

er; h: TEHandle);

ndle;

: TP2PerfGlobals);

 17;

xtStyle; redraw: Boolean; hTE: TEHandle);

r; hTE: TEHandle);

Handle);

Rect): TEHandle;

 h: TEHandle);

 -1;

 0;

 1;

h: LongInt; h: TEHandle);



Handle);

): CharsHandle;

R theStyle: TextStyle;

gInt;

TE: TEHandle): Point;

TEHandle): Integer;

nt; hTE: TEHandle): LongInt;

Err;

Handle);

Handle);

Handle);

Handle);

Handle);

Boolean; h: TEHandle);

Handle);

; hTE: TEHandle);

Handle);

d): Extended;

d): Extended;

Hz;



t: LongInt);

 0;

Record): Boolean;

teger): Boolean;

; theWindow: WindowPtr);

 0;

e: Integer);

: Integer);

 0;

 -1;

lockPtr): OSErr;

VAR dst: Point);

tr; s: Str255);

ddress): AnAddress;

5): Integer;

 VAR theNum: LongInt);

): Extended;

d: Decimal; VAR ValidPrefix: Boolean);



 0;

erProc: ProcPtr): Integer;

16384;

32768;

6384;

lean;

 denom: Point; VAR info: FontInfo): Integer;

: Ptr; numer, denom: Point);

ct; ovWd, ovHt: Integer);

; rgn: RgnHandle);

erb; r: Rect);

yteCount: Integer);

 poly: PolyHandle);

erb; r: Rect);

: Point);

yteCount: Integer);

 3;

er; dataHandle: Handle);

t: Rect; mode: Integer; maskRgn: RgnHandle);

tartAngle, arcAngle: Integer);

teger; csParamPtr: Ptr): OSErr;

 8;

ngInt; CompletionRtn: ProcPtr);

gInt;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

 2;

 1;

 0;

 3;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

t: Integer);

Handle; theSex: Sex);

dle; theRate: Integer);

itch: Integer; theMode: F0Mode);

eech: SpeechHandle): SpeechErr;

SpeechHandle);

-79;

: Fixed);

lean;

 0;

 -1;

 1;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

Handle; async: Boolean): OSErr;

init: LongInt; userRoutine: ProcPtr): OSErr;

cmd: SndCommand): OSErr;

Command; noWait: Boolean): OSErr;

killNow: Boolean): OSErr;

d: SndCommand): OSErr;

cPtr; id: Integer; init: LongInt): OSErr;

ract): Fixed;

lockPtr): OSErr;

 theSlot: Integer): OSErr;

 theSlot: Integer): OSErr;

eger): Fixed;

3109;

: Fixed);

eight: Integer; fUpdate: Boolean);

Handle): LongInt;

Handle; w, h: Integer);

; theSlot: Integer): OSErr;

; theSlot: Integer): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

d): Extended;

ded; x: Extended);

ed): Integer;

 20;

d: Cursors);

: WindowPtr);



; showFlag: Boolean);

r; itemNo: Integer);



ControlHandle);

512;

; offsetPt: Point);

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

tr255; dlgHook: ProcPtr; VAR reply: SFReply);

cPtr; VAR reply: SFReply; dlgID: Integer; filterProc: ProcPtr);

TypeList; dlgHook: ProcPtr; VAR reply: SFReply; dlgID: Integer; filterProc: ProcPtr);

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

teger; typeList: SFTypeList; dlgHook: ProcPtr; VAR reply: SFReply);

lockPtr): OSErr;

 THz);

Ptr; title: Str255);

Ptr; data: LongInt);

tr; hTE: TEHandle);

r; thePic: PicHandle);

ewColorTable: WCTabHandle);

RefNum: Integer): OSErr;

tr: DefVidPtr);

; trapNum: Integer);

eTimeRec);

Ptr): OSErr;

: Integer);

: Integer);

andle; hTE: TEHandle);

ndle; strNew: Str255);

s: QDProcs);

 Integer);

; param: LongInt): OSErr;

undDir);

: Boolean);

: Boolean);

ID: Integer; name: Str255);

; attrs: Integer);

le; attrs: Integer);

p, right, bottom: Integer);

, right, bottom: Integer);

wSize: Size);

D; x, y, z: Fixed);

t2D; x, y: Fixed);

; h, v: Integer);

undPre);

BitMap);

ort3DPtr);

GrafPtr);

 PenState);

tr: DefOSPtr);

Integer);

t: Integer);

: Handle);

MCInfoHandle);

menuCEntries: MCInfoPtr);

; text: Str255);

 Integer; styleVal: Style);

 Integer; markChar: char);

: Integer; iconNum: Byte);

nteger; itemString: Str255);

newSize: Size);

ongInt);

n; b: Boolean);

: ProcPtr);

DHandle);

: Boolean);

le: Boolean);

teger; posOff: LongInt): OSErr;

: Boolean);

efNum: Integer): OSErr;

nteger; FndrInfo: FInfo): OSErr;

n; b: Boolean);

: Integer);

gEOF: LongInt): OSErr;

ram: LongInt): OSErr;

ironment);

r; aTable: CSpecArray);

gnHandle);

kind: Integer; item: Handle; box: Rect);

: Integer; value: Boolean);

 PixPatHandle);

tr: DefRecPtr);

gInt): OSErr;

: Integer);

 Cursor);

ndle; theValue: Integer);

ndle; theValue: Integer);

ndle; theValue: Integer);

 newColorTable: CCTabHandle);

ndle; newProc: ProcPtr);

Handle; title: Str255);

Handle; data: LongInt);

MapHandle);

 cPix: ColorSpec);

gnHandle);

tr; hTE: TEHandle);

nteger);

CrsrHandle);

mit: Ptr);

tr: Ptr);

 ADBAddr: ADBAddress): OSErr;

erSta: SerStaRec): OSErr;

Ptr; serBLen: Integer): OSErr;

teger): OSErr;

Config: Integer): OSErr;

lags: SerShk): OSErr;

 count: LongInt): OSErr;

teger): OSErr;

hind: WindowPtr);

eger; startSel, endSel: Integer);

: WindowPtr);

 15;

-80;

LFILE; recno: LongInt);

ght, words: Integer; seedH, seedV: Integer);

 dstRgn: RgnHandle);

 dstRect: Rect): Boolean;

-81;

R d: DateTimeRec);

lockPtr): OSErr;

lockPtr): OSErr;

lockPtr): OSErr;

 7;

Ptr): OSErr;

Ptr): OSErr;

eger;

nteger): OSErr;

nteger): OSErr;

Err;

Ptr): OSErr;

Ptr): OSErr;

teger): OSErr;

Integer): OSErr;

Err;

ger; wait: LongInt): OSErr;

nt: Integer): OSErr;

teger; updateRgn: rgnHandle);

 16;

 15;

crnVRes: Integer);

 13;

 5;

 6;

 2;

 4;

 5;

lockPtr): OSErr;

  1;

 6;

 8;

 2;

 4;

lockPtr): OSErr;

mRect, toRect: Rect);

r, zFactor: Fixed);

lockPtr): OSErr;

lockPtr): OSErr;

xtended): Extended;

 3;

WindowPeek);

ndle; VAR selection: ReqListRec);

 8;

efNum: Integer): OSErr;



Handle): LongInt;

: LongInt);

: Fixed);

-196;

-197;

ce: Handle);

ce: Handle);

d): Extended;

heID: Integer): Handle;

RGBColor);

RGBColor);

VAR hColor: HSVColor);

VAR hColor: HSLColor);

VAR cColor: CMYColor);

-51;

FILE; OPT fname: STRING);

le; VAR selection: ReqListRec);



128;

 64;

ed: Size);

 32;

 8;

 4;

-192;

 16;

-193;



FILE; OPT fname: STRING);

 reserve: Boolean);

eger;

 3;

 2;

1096;

1105;

teger; newName: Str255): OSErr;



quo: Integer): Extended;

s, diacSens: Boolean): Integer;

ce: Handle);

nded): Relop;

205;

 4;

dle; r: Rect);

gnHandle): Boolean;

): Handle;

3108;

yteCount: Size);

ze: Integer): Boolean;

olor): Boolean;

3105;

XT; OPT EXPR_LIST);

Length: LongInt; PhoneticOutput: Handle): SpeechErr;

ongInt): OSErr;

; OPT EXPR_LIST);

 64;

 16;

ded): Extended;

eger;

PortSel): OSErr;

: SPortSel);

 10;

 2;

 2;

54936;



sType; source: Ptr): LongInt;

 1;

 7;

 5;

 6;

3999;

 2;

IV PASCALFILE);

 0;

fterPurge: LongInt);

ed: Size);

; VAR angle: Integer);

r): THz;

ndle; size: LongInt): OSErr;

Handle; size: LongInt): OSErr;

le; size: LongInt): OSErr;

RgnHandle): Boolean;

 Rect): Boolean;

 VAR dstRect: Rect);

rint): Boolean;

rint): TPPrDlg;

rint): Boolean;

Integer);



: Ptr; pDevBuf: Ptr; VAR PrStatus: TPrStatus);

9002;

9003;

9001;

 protect: Boolean);

9000;

 pPageFrame: TPRect);

PrPort; pIOBuf: Ptr): TPPrPort;



ironment);

nvironment);



intDst: THPrint);

rint): TPPrDlg;

rint): Boolean;

 THPrint);

a: Ptr);

eger;









Init: ProcPtr): Boolean;

1, lParam2, lParam3: LongInt);

 TPPrPort);

 TPPrPort);





000944;

entMsg: LongInt): OSErr;

-40;

 5;

ght: Integer);

 3;

INTER; style: Integer; bufsize: Integer);

nt: Boolean);

IV PASCALPOINTER);

e: Boolean);

Boolean);

wFname: STRING);

 STRING);

 theIcon: Handle);

eIcon: cIconHandle);

TER; allowNonCont: Boolean; allowDispose: Boolean);

 PASCALPOINTER; allowNonCont: Boolean; forDispose: Boolean);

ar: TEXT);

ASCALFILE): LongInt;

IV PASCALFILE);

 2;

: Integer; VAR leftSide: Boolean): Integer;

: Fixed);

ePt: Point): LongInt;

 1;

 0;

 64;

er; dataHandle: Handle);

-54;

stogram: Boolean; rptFileColumns: Integer): Integer{OSErr};

als; turnOn: Boolean): Boolean;

ght: Integer);

PatHandle);

Pattern);



Integer);

; aSync: Boolean): OSErr;

rmBlkPtr): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

 aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

rmBlkPtr): OSErr;

rmBlkPtr): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

 aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

 aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

r; aSync: Boolean): OSErr;

 aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

 aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

rmBlkPtr): OSErr;

r; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

 aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

; aSync: Boolean): OSErr;

 10;

 9;

 8;

 11;

Ptr): Boolean;

 16;

te2, cite3: Str255);

-50;

, ovHt: Integer);

gnHandle);

Rect);

olyHandle);

Rect);

 clobbered: RgnHandle);

k; clobbered: RgnHandle);

e, arcAngle: Integer);

Ptr; srcBytes: Integer);

 4;

ent: EventRecord): Boolean;

-49;

2048;

 Integer): OSErr;



eger; permission: byte): Integer;

eger; VAR refNum: Integer): OSErr;

r255): Integer;

GrafPtr);

Handle;

ct): PicHandle;

rRefNum: Integer): OSErr;

255): Integer;

CGrafPtr);

ct): PicHandle;

ort3DPtr);

ALFILE; fname: STRING);

RGBColor);

 1;

 dh, dv: Integer);

dh, dv: Integer);

; dh, dv: Integer);

-65;

4096;



AR theString: Str255);

ended; VAR s: DecStr);

ed): single;

ed): LongInt;

ed): Integer;

d): Extended;

ed): double;

nded; VAR d: Decimal);

ded): comp;

 0;

-35;

-56;

-102;

 6;

 5;

 4;

 7;

 14;

 13;

 12;

 15;

 1;

erProc: ProcPtr): Integer;

1103;

-100;

 0;

1101;

Reader';

 0;

-66;

3102;

 0;

-57;

 4;

 '';

 0;

-71;

 14;

-64;

1104;

 0;

-93;

-67;

-109;

gle): single;

ded): Extended;

ble): double;

 2;

 Integer; behind: WindowPtr; goAwayFlag: Boolean; refCon: LongInt): WindowPtr;

55): StringHandle;

 12;

andle;

: Size): Ptr;





itle: Str255): MenuHandle;

Size): Handle;

de: LongInt): GDHandle;

ndle;

behind: WindowPtr; goAwayFlag: Boolean; refCon: LongInt; itmLstHndl: Handle): DialogPtr;

Integer; behind: WindowPtr; goAwayFlag: Boolean; refCon: LongInt): WindowPtr;

eger; min: Integer; max: Integer; contrlProc: Integer; refCon: LongInt): ControlHandle;

; behind: WindowPtr; goAwayFlag: Boolean; refCon: LongInt; items: Handle): DialogPtr;

1024;

 10;

Err;

 26;

ntityPtr): OSErr;

; async: Boolean): OSErr;

1028;

1025;

1029;

; async: Boolean): OSErr;

Err;

VAR abEntity: EntityName; VAR address: AddrBlock): OSErr;

1027;

; async: Boolean): OSErr;

1026;

1024;

r): Extended;

 4;

: LongInt; ptr2: Ptr; len2: LongInt): LongInt;

 2;

Err;

Err;

Integer; BringToFront: Boolean);

z: Fixed);

 Fixed);

Integer);

pGlobal: Integer);

andle);

Handle; h, v: Integer);

dz: Fixed);

: Fixed);

 Integer);

 2;

 1;



 4;

 VAR itemHit: Integer);

-41;

int): LongInt;

): LongInt;



-111;

-112;

-117;

-108;

Err;

tAddr, charLocs: Ptr);

slop: Integer; charLocs: Ptr);

slop: Integer; charLocs: Ptr);

 0;

 2;

 1;

Handle): LongInt;

00000;

 Size): Size;

gInt;



omRect, toRect: Rect);

Rect, toRect: Rect);

128;

mRect, toRect: Rect);

romRect, toRect: Rect);

 64;

 32;

 myColor: RGBColor);

: ITabHandle; res: Integer);

 11;

137;

 7;

 0;

 1;

Phonemes: Handle): SpeechErr;

 4;

 lHandle: ListHandle);

teger; lHandle: ListHandle);

 Cell; lHandle: ListHandle);

theCell: Cell; lHandle: ListHandle);

; VAR theCell: Cell; lHandle: ListHandle): Boolean;

r; lHandle: ListHandle);

000000;

l: Cell; lHandle: ListHandle);

010000;

020000;

030000;

03FFFF;

03FFFE;

01FFFD;

02FFFD;

000001;

 12;

t, bottom: Fixed);

128;

VAR dst: Int64Bit);

nt): Fixed;

 6;

d): Extended;

d): Extended;

d): Extended;

: Point);

gInt;

ce: Handle);

 8;

 2;

 16;

 32;

: Cell; lHandle: ListHandle): Boolean;

indowPtr; drawIt, hasGrow, scrollHoriz, scrollVert: Boolean): ListHandle;

d): Extended;

tHandle): Cell;

 0;

z: Fixed);

 Fixed);

Integer);

dz: Fixed);

: Fixed);

 Integer);

000010;

000011;

 2;

ll; lHandle: ListHandle): Boolean;

; theCell: Cell; lHandle: ListHandle);

Cell: Cell; lHandle: ListHandle);

 64;

 1;

Handle: ListHandle);

 2;

 1;

lHandle: ListHandle);

ListHandle);

r; lHandle: ListHandle);

r; lHandle: ListHandle);

Handle: ListHandle);

 3;

; lHandle: ListHandle): Boolean;

andle: ListHandle);

ListHandle);

-64;

; async: Boolean): OSErr;

 20;

; async: Boolean): OSErr;

ecHandle): OSErr;

-94;

 protoPtr: Ptr): OSErr;

ABByte): OSErr;

theCell: Cell; lHandle: ListHandle);

Handle: ListHandle): Integer;

Handle: ListHandle): Integer;

andle: ListHandle);

olyHandle);

: PicHandle);

teger): OSErr;

: WindowPtr);

 16;

 4;

er; VAR state: LongInt): LongInt;

Integer);

Integer);

 8;

 3;

00FF00;

s: Boolean; VAR result: Str255);

n; VAR result: Str255; intlParam: Handle);

Integer; intlParam: Handle);

lean;

 bLen: Integer): Integer;

 bLen: Integer): Integer;

eger): Handle;

tr255): Integer;

 DateForm; VAR result: Str255);

; VAR result: Str255; intlParam: Handle);

tr255): Integer;

128;

lean;

ecord): Boolean;

lean;

 3;

9999;

 1;

120;

 5;

 6;

 7;

 4;

128;

128;

-36;

$10;

 3;

 8;

 7;

, ovHt: Integer);

gnHandle);

Rect);

olyHandle);

Rect);

r: RGBColor);

e, arcAngle: Integer);

 1;

RgnHandle);

t: Rect);

 1;

 -1;

 20;

 6;



129;

 2;

ng: Str255; itemNum: Integer);

 dh, dv: Integer);

dh, dv: Integer);

 ResType; afterItem: Integer);

 beforeId: Integer);

 22;

 23;

 1;

: Integer; limitPtr, startPtr: Ptr);



Err;

lockPtr): OSErr;

eger;

aVariant: Integer);

GrafPtr);

 Integer);



-77;

Ptr: Ptr);

Ptr: Ptr);

: LongInt; GDH: GDHandle);



ame: Str255; ShowToolErrNbrs: Boolean);

c: ProcPtr);

NIV acurHandle);



CGrafPtr);

 3;





 5;

 6;

pStuff;

 16;

 4;

 21;

AR aColor: RGBColor);

 0;

 3;

 11;

 10;

-108;

-27;

 8;

 LongInt);



IV SignalHandler): SignalHandler;

 prevMap: SignalMap);

SignalMap);

Map): SignalMap;

fName: STRING; mode: LongInt);

UNIV LongInt);

: LongInt; whence: LongInt): LongInt;

 LongInt; arg: UNIV LongInt): LongInt;

lue: UNIV IEString): Boolean;

nt; arg: UNIV LongInt): LongInt;

 LongInt);

0300;

0200;

0100;



 32;

 1;

 32;

andle);

VAR rColor: RGBColor);

VAR rColor: RGBColor);

ate: SignedByte);

andle);

andle);

Handle): Integer;

andle);

andle);

tr; fHiLite: Boolean);

ondOffset: Integer; VAR offsets: OffsetTable);

stOffset, secondOffset: Integer;

 Integer);

le; hiliteState: Integer);

RGBColor);

 7;



: WindowPtr);



r; itemNo: Integer);



ControlHandle);

: SignedByte;

andle);

 1;

 Handle): OSErr;

dle): THz;

 Handle): OSErr;

ndle;

t: Point; bBox: Rect): LongInt;

341;

 3;

 Integer);

: Point);

-52;

Hz;

dowPtr): Integer;

r; VAR title: Str255);

dowPtr): LongInt;

t: GrafPtr);

owPtr): PicHandle;

R vRefNum: Integer): OSErr;

 vRefNum: Integer): OSErr;

efNum: Integer; VAR FreeBytes: LongInt): OSErr;

tr: DefVidPtr);

rPtr;

rPtr;

eger): LongInt;

: Str255; ErrMsg: StringPtr);

ateTimeRec);

PPtr;





 ErrMsg: StringPtr);

s: Integer; targetTbl: CTabHandle);

): StScrpHandle;

): TEStyleHandle;

er): StringHandle;

l: Integer);

 14;

 8;

Integer): LongInt;

; VAR offset: LongInt): LongInt;

ndDir;

ID: Integer): Handle;

; VAR theType: ResType; VAR name: Str255);

eger): Integer;

Handle): Integer;

r): Size;

ndPre;

 Port3DPtr);

: GrafPtr);

r): PixPatHandle;

ger): Boolean;

er): PicHandle;

e: PenState);

: Point);

er): PatHandle;

ent: EventRecord): Boolean;

tr: DefOSPtr);

 1;

t: Integer): OSErr;

 7;

ent: EventRecord): Boolean;

andle): GDHandle;

tr; behind: WindowPtr): WindowPtr;

nteger): Handle;

tr; behind: WindowPtr): DialogPtr;

tr; behind: WindowPtr): WindowPtr;

: WindowPtr): ControlHandle;

name: Str255): Handle;

: Point);

er): MenuHandle;

ndle;

er): MenuHandle;



 Integer): MCInfoPtr;



Rect): GDHandle;

tr;



 keyMap);

VAR text: Str255);

nteger; VAR styleVal: Style);

nteger; VAR markChar: char);

Integer; VAR iconNum: Byte);

eger; VAR itemString: Str255);

ype; index: Integer);

stID: Integer; index: Integer);

ndex: Integer): Handle;

tID: Integer; index: Integer);

ableIndex: Integer): ADBAddress;

eger): Handle;

le): Size;

gInt;



rPtr;

filePos: LongInt): OSErr;

: RGBColor);

 VAR theName: Str255);

: FontInfo);

AR familyID: Integer);

eger; VAR FndrInfo: FInfo): OSErr;

rPtr;

LogEOF: LongInt): OSErr;

ger): LongInt;

nvironment);

 5;

rPtr;

 6;

4000;

nd: Integer; VAR item: Handle; VAR box: Rect);





tr: DefRecPtr);

er): DCtlHandle;

gInt;

: LongInt);

: CGrafPtr);

rolHandle): Integer;

ger): CursHandle;



rolHandle): Integer;

rolHandle): Integer;

rolHandle): Integer;

rolHandle): ProcPtr;

ndle; VAR title: Str255);

r): CTabHandle;

rolHandle): LongInt;

er): ColorSpec;

RGBColor; VAR outColor: RGBColor): Boolean;

gnHandle);

er): cIconHandle;

er): CCrsrHandle;

gInt;

 3;

: RGBColor);

awHndl: AuxWinHndl): Boolean;

AR ACHndl: AuxCtlHndl): Boolean;

um: Integer; VAR apParam: Handle);

tr;



AR theFile: AppFile);

eger;

ADBAddr: ADBAddress): OSErr;

ID: Integer): Handle;

name: Str255): Handle;

ype; index: Integer);

ndex: Integer): Handle;

IV PASCALFILE);

 3;

 0;

B002;

B003;

B001;

4000;

 -3;

 1;

 2;

 LongInt; buffPtr: Ptr): OSErr;

 1;

 2;

-59;

 LongInt; buffPtr: Ptr): OSErr;

 4;

 3;

 1;

eger; VAR refNum: Integer): OSErr;

 1;

 3;

 2;

-127;

efNum: Integer): OSErr;

 0;

teger): OSErr;

 0;

owPtr;

gInt;

 Integer);

: Integer);

 64;

, ovHt: Integer);

gnHandle);

Rect);

olyHandle);

Rect);

e, arcAngle: Integer);

t): Fract;

d): Fract;

act): Fract;

act): Fract;

d): Fract;

): Extended;

t): Fixed;

 LongInt);

ACB0;



: FontMetricRec);

nteger): Integer;

-38;

-43;

put): FMOutPtr;

RefNum: Integer): OSErr;

opMask: Integer);

 4;

-45;

 Integer);

): Integer;

 Integer): Fixed;

xed): Fixed;

 1;

B000;

xed): Fixed;

gInt): Fixed;

): Extended;

: SmallFract;

): LongInt;

d): Fract;

-84;

6384;



oolean; breaks: BreakTablePtr; VAR offsets: OffsetTable);

set: Integer; leftSide: Boolean;

Window: WindowPtr): Integer;

ePoint: Point): Integer;

 VAR theControl: ControlHandle): Integer;

 Integer; pat: Pattern);

e; pat: Pattern);

at: Pattern);

le; pat: Pattern);

at: Pattern);

 13;

nteger; pp: PixPatHandle);

 pp: PixPatHandle);

 PixPatHandle);

; pp: PixPatHandle);

 PixPatHandle);

le: Integer; pp: PixPatHandle);

ngle: Integer; pat: Pattern);

8192;

 0;

 0;

 -2;

-47;

3104;

-58;

d): Extended;

d): Extended;

d): Extended;



-95;

 1;

 -1;

ent: EventRecord): Boolean;

2288;

 ProcPtr);

, ovHt: Integer);

gnHandle);

Rect);

olyHandle);

Rect);

e, arcAngle: Integer);

s, diacSens: Boolean): Boolean;

nHandle): Boolean;

 Rect): Boolean;

oint): Boolean;

 TEXT): Boolean;

-39;

 PASCALFILE): Boolean;

hine: Integer);

r; qHeader: QHdrPtr);

: WindowPtr);

e; item: Integer);

dle): Boolean;

): Boolean;

andle);

RefNum: Integer): OSErr;

 16;

-48;

ElemPtr): OSErr;

 2;

-34;

 status: DrvSts): OSErr;

2048;

 11;

te, byteCount: Integer);

tr255);

dle; dstRect: Rect);

k; fUpdate: Boolean);



ength, slop: Integer);

ength, slop: Integer);

: WindowPtr);

DialogPtr);

: WindowPtr);

 0;

 char);

tPt: Point; boundsRect: Rect);

ect: Rect; axis: Integer; actionProc: ProcPtr): LongInt;

 bounds: Rect; slopRect: Rect; axis: Integer);

 7;

teger): OSErr;

 0;

DialogPtr);

DialogPtr);

DialogPtr);

DialogPtr);

lName: Str255): OSErr;

teger): OSErr;

 8;



 Ptr);

PatHandle);

MapHandle);

andle);

DHandle);

: WindowPtr);

gnHandle);

enuHandle);

ControlHandle);

DialogPtr);

CTabHandle);

cIconHandle);

CrsrHandle);

MCInfoHandle);

 4;

128;

 7;

teger): OSErr;

e; item: Integer);

-120;

-33;

 2;



teger): OSErr;

 dstRgn: RgnHandle);

sage: LongInt): Integer;

$13;

alogPtr; VAR itemHit: Integer): Boolean;

 2;

ce: Handle);

 16;

 16;

Header: QHdrPtr): OSErr;

oint): LongInt;

c: ProcPtr);

; itemNum: Integer);

Item: Integer);

 Integer);

: ProcPtr);

AR finalTicks: LongInt);

127;

255;

imal; VAR s: DecStr);

l): Extended;

m: Boolean; async: Boolean): OSErr;

-91;

 26;

rs: Boolean; async: Boolean): OSErr;

ecHandle): OSErr;

sktListener: Ptr): OSErr;

-92;

 Byte): OSErr;

 1;

; VAR s: LongInt);

-68;

3072;

1024;

2048;

 0;

273;

 8;

obals; pc: LongInt): LongInt;

eger;

 4;

 d: Decimal; VAR ValidPrefix: Boolean);

 2;

e: Str255);

reator: OSType; fileType: OSType): OSErr;

eger;

Type): Integer;

ndle): Integer;

r; VAR count: Integer);



eger;

Type): Integer;

 Integer);

: Integer);

d): Extended;

ded): Extended;

gn: RgnHandle);

: PixPatHandle);

: PixMapHandle);

: Rect; mode: Integer; maskRgn: RgnHandle);

p; srcRect, maskRect, dstRect: Rect);

: PixMap; srcRect, maskRect, dstRect: Rect);

t: Rect; mode: Integer; maskRgn: RgnHandle);

teger; csParamPtr: Ptr): OSErr;

ded): Extended;

 Size): Size;

$11;

: Integer);

GBColor): LongInt;

VAR rColor: RGBColor);

256;

 0;

 Integer);

: WindowPtr);

RgnHandle);

 Integer);

GrafPtr);







teger): OSErr;

DialogPtr);

 Integer);

CGrafPtr);

Rect);

WindowPeek);

dst1, dst2: POINT): Boolean;



): NumClass;

d): NumClass;

): NumClass;

: NumClass;

3103;

 1;

 1;

entRecord): Boolean;

$12;

Integer; checked: Boolean);

 1;

): Integer;

fset: Integer): Integer;

: Fixed);

0000FF;

fset: Integer): Integer;

 Integer; direction: Integer): Integer;

ce: Handle);

1102;

 2;

erProc: ProcPtr): Integer;

-75;

 2;

k; clobbered: RgnHandle);

WindowPeek);

enuHandle);

dstRow, height, words: Integer);

 2;

 11;

 nBytes: LongInt; OPT stByte: LongInt): LongInt;

 nBytes: LongInt; OPT stByte: LongInt): LongInt;

 19;

lean;

 3;

 2;

3101;

128;

 0;

 1;

: WindowPtr);

 -9;

409;

 2;

nBlocks: Integer; OPT stBlock: Integer): Integer;

nBlocks: Integer; OPT stBlock: Integer): Integer;

tr; byteCount: Size);

 33;

 5;

um: LongInt): Boolean;

nt: Integer): LongInt;

bitNum: LongInt);

bitNum: LongInt);

 -8;

: WindowPtr);

 0;

-37;

 3;

 2;

 1;

 7;

 10;

 14;

189;

 0;

 22;

 30;

380;

 46;

 4;

 62;

 94;

-122;

-60;

-72;

-73;

-69;

1100;

-70;

1099;

PatHandle);

Pattern);

 LongInt);

 8;

 32;

 5;

teger): OSErr;

Err;

; async: Boolean): OSErr;

; async: Boolean): OSErr;

 56;

; async: Boolean): OSErr;

; async: Boolean): OSErr;

; async: Boolean): OSErr;

; async: Boolean): OSErr;

R atpSocket: Byte): OSErr;

Err;

3106;

; async: Boolean): OSErr;

 Byte): OSErr;

3107;

ecHandle): OSErr;

 7;

tr; async: Boolean): OSErr;

tr; async: Boolean): OSErr;

tr; async: Boolean): OSErr;

tr; async: Boolean): OSErr;

tr; async: Boolean): OSErr;

tr; async: Boolean): OSErr;

tr; async: Boolean): OSErr;

tr; async: Boolean): OSErr;

d): Extended;

d): Extended;

d): Extended;

 1;

 0;

Hz;

 1;

$14;

le; data: Str255);

32768;

 15;

6384;

 14;

8192;

 13;

4096;

 12;

 -7;

ded): Extended;

ed): Integer;

 3;

1024;



 count: LongInt): OSErr;

 12;

erProc: ProcPtr): Integer;

 -6;

tr; async: Boolean): OSErr;

c: ProcPtr);

Type; theID: Integer; name: Str255);

; theType: ResType);

-194;

-195;

ID: Integer; name: Str255);

VAR dst: Point);

; ErrMsg: StringPtr);

um: Integer; QEl: drvQElPtr);

: ProcPtr);



er: Ptr; commandNum: Integer): OSErr;

256;

 1;

 8;